package ui.magic.magiclibs.container.Absolute;

import android.content.Context;
import android.graphics.Point;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.AbsoluteLayout;

import java.util.Vector;

import ui.magic.magiclibs.container.Base.MagicInterface;
import ui.magic.magiclibs.container.Base.MagicType;

/**
 * Created by liushiyin on 2017/10/23.
 */

/**
 *MagicUi的绝对布局
 * 你可像绝对布局一样指定子节点的位置和大小，当然这都是相对于父节点的位置和大小
 * 比如你在添加子节点时如下使用addChildView(button,5,5,20,20),
 * 这将表示子节点相对于父节点左上角，向右移父节点宽度的5%大小，
 * 向下移相对于父节点的高度的5%大小，子节点的宽度为父节点的20%，
 * 子节点的高度为父节点的20%
 */
public class AbsoluteMagicUi extends AbsoluteLayout implements MagicInterface {

    private Point magicSize;   //保存UI组件尺寸
    private Vector<View> childList;
    private Vector<Params> paramsList;
    private MagicType type;

    /*
      *在自己的尺寸改变时调整子组件的大小
     */
    private void reOrderChildSize(){
        int count=childList.size();
        for(int i=0;i<count;++i){
            Params params=paramsList.get(i);
            View v=childList.get(i);
            //change(v,params,1);
            super.removeView(v);
            addChildTmp(v,params.perx,params.pery,params.perW,params.perH,-1);
        }
    }

    /*
    *设置UI组件大小，同时会调整子组件大小，自己不要轻易调用此函数，
    *而应有UI组件自身在适当的时候调用
    *@Param width：宽度
    *@Param height：高度
     */
    @Override
    public void setMagicSize(int width, int height) {
        magicSize.x=width;
        magicSize.y=height;
        reOrderChildSize();
    }

    public AbsoluteMagicUi(Context context) {
        super(context);
        init(MagicType.As_Child);
    }

    public AbsoluteMagicUi(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(MagicType.As_Child);
    }

    public AbsoluteMagicUi(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init(MagicType.As_Child);
    }

    /*
    *进行一些初始化操作
     */
    public void init(MagicType type){
        this.type=type;
        magicSize=getWindowSize();
        childList=new Vector<>();
        paramsList=new Vector<>();
    }

    /*
    *添加View子节点
    * @Param v：View子节点
    * @Param perx：字节点相对于父节点的x坐标（0~100的浮点数，表示子节点相对于父节点坐标占父节点大小的百分比）
    * @Param pery:字节点相对于父节点的y坐标（0~100的浮点数，表示子节点相对于父节点坐标占父节点大小的百分比）
    * @Param perWidth：0~100的浮点数表示子节点宽度为父节点宽度的百分比值
    * @Param perHeight：0~100的浮点数表示子节点宽度为父节点高度的百分比值
     */
    public void addChild(View child,float perx,float pery,float perWidth,float perHeight){
        addChildTmp(child,perx,pery,perWidth,perHeight,-1);
        childList.add(child);
        paramsList.add(new Params(perx,pery,perWidth,perHeight));
    }

    /*
    *addViewTmp的中间过程
     */
    private void addChildTmp(View child,float perx,float pery,float perWidth,float perHeight,int index){
        float rex=(perx/MAX)*magicSize.x;
        float rey=(pery/MAX)*magicSize.y;
        float rew=(perWidth/MAX)*(float) magicSize.x;
        float reh=(perHeight/MAX)*(float) magicSize.y;
        if(child instanceof MagicInterface){
            ((MagicInterface)child).setMagicSize((int) rew,(int) reh);
        }
        LayoutParams params=new LayoutParams((int) rew,(int) reh,(int) rex,(int) rey);
        super.addView(child,index,params);
    }

    /*
    *获取子节点相对于父节点的百分比位置
    * @Param v：子节点
    * @return FVector：成功则返回子节点相对于父节点的百分比位置，失败则返回坐标值为（-1，-1）的向量
     */
    public FVector getChildPerSize(View child){
        int index=childList.indexOf(child);
        if(index!=-1){
            Params params=paramsList.get(index);
            return new FVector(params.perW,params.perH);
        }else{
            return null;
        }
    }

    /*
    *获取子节点相对于父节点的百分比位置
    * @Parma v：子节点
    * @return FVector：成功则返回子节点相对于父节点的百分比位置，失败测返回（-1，-1）的向量
     */
    public FVector getChildPerLocation(View child){
        int index=childList.indexOf(child);
        if(index!=-1){
            Params params=paramsList.get(index);
            return new FVector(params.perx,params.pery);
        }else{
            return null;
        }
    }

    /*
    *调整子节点的位置
    *@param child:需要调整位置的字节点
    * @param perx：新位置的相对x坐标
    * @Param pery：新位置的相对y坐标
    */
    public boolean changeChildLocation(View child,float perx,float pery){
        int index=this.indexOfChild(child);
        if(index!=-1){
            Params params=paramsList.get(index);
            params.perx=perx;
            params.pery=pery;
            change(child,params,-1);
            return true;
        }else{
            return false;
        }
    }

    /*
    *调整子节点的相对尺寸
    *@Param child:需要调整的子节点
    * @Param perWidth：新的百分比大小
    * @Param perHeight：新的百分比大小
     */
    public boolean changeChildSize(View child,float perWidth,float perHeight){
        int index=this.indexOfChild(child);
        if(index!=-1){
            super.removeView(child);
            Params params=paramsList.get(index);
            params.perW=perWidth;
            params.perH=perHeight;
            //change(child,params,1);
            this.addChildTmp(child,params.perx,params.pery,perWidth,perHeight,index);
            return true;
        }else{
            return false;
        }
    }

    private void change(View child,Params params,int flag){
        float rex=(params.perx/MAX)*magicSize.x;
        float rey=(params.pery/MAX)*magicSize.y;
        float rew=(params.perW/MAX)*(float) magicSize.x;
        float reh=(params.perH/MAX)*(float) magicSize.y;
        child.layout((int)rex,(int)rey,(int)(rex+rew),(int) (rey+reh));
        if(flag>0&&child instanceof MagicInterface){
            ((MagicInterface)child).setMagicSize((int) rew,(int) reh);
        }
    }

    /*
    *移除View子节点
     */
    public boolean removeChild(View child){
        int index=childList.indexOf(child);
        if(index!=-1){
            super.removeView(child);
            childList.remove(index);
            paramsList.remove(index);
            return true;
        }else{
            return false;
        }
    }

    /*
    *获取手机屏幕的大小
    * @return Point：保存手机屏幕大小的向量
     */
    public Point getWindowSize(){
        WindowManager wm=(WindowManager)getContext().getSystemService(Context.WINDOW_SERVICE);
        Point point=new Point();
        wm.getDefaultDisplay().getSize(point);
        return  point;
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        if(type==MagicType.Self_Init){
            int width=getMeasuredWidth();
            int height=getMeasuredHeight();
            if(magicSize.x!=width||magicSize.y!=height){
                setMagicSize(width,height);
            }
        }
    }

    public void setSelfInit(){
        type=MagicType.Self_Init;
    }

    public void setAsChild(){
        type=MagicType.As_Child;
    }

    /*
        *以下函数废弃不再使用，不要尝试使用它们，不保证使用后会发生什么错误
         */
    @Override
    @Deprecated
    public void addView(View child) {super.addView(child);}
    @Override
    @Deprecated
    public void addView(View child, int index) {super.addView(child, index);}
    @Override
    @Deprecated
    public void addView(View child, int width, int height) {super.addView(child, width, height);}
    @Override
    @Deprecated
    public void addView(View child, ViewGroup.LayoutParams params) {super.addView(child, params);}
    @Override
    @Deprecated
    public void addView(View child, int index, ViewGroup.LayoutParams params) {super.addView(child, index, params);}

    @Override
    @Deprecated
    public void removeView(View view) {super.removeView(view);}
    @Override
    @Deprecated
    public void removeViewAt(int index) {super.removeViewAt(index);}
    @Override
    @Deprecated
    public void removeAllViews() {super.removeAllViews();}
}
